src/ContextProcessor/ThrowableProcessor.php (2)

27-37: Leverage the recursiveProcessor to serialize chained exceptions (and silence PHPMD).

Using the callback to process the previous throwable makes output richer and resolves the unused-parameter warning.

Apply:

-    public function process(mixed $value, callable $recursiveProcessor): mixed
-    {
-        return [
+    public function process(mixed $value, callable $recursiveProcessor): mixed
+    {
+        $previous = $value->getPrevious();
+        return [
             'class' => \get_class($value),
             'message' => $value->getMessage(),
             'code' => $value->getCode(),
             'file' => $value->getFile(),
             'line' => $value->getLine(),
-            'trace' => $value->getTraceAsString(),
+            'trace' => $value->getTraceAsString(),
+            'previous' => $previous !== null ? $recursiveProcessor($previous) : null,
         ];
     }

If you prefer not to change the payload shape right now, minimally suppress PHPMD on this method:

     /**
      * @param \Throwable $value
      * @param callable(mixed): mixed $recursiveProcessor
      * @return array<string, mixed>
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
      */

---

35-35: Consider emitting structured stack frames (optional).

Arrays from getTrace() are more machine-friendly than a single string. If backward compatibility allows, expose frames (e.g., as traceFrames) alongside trace.

src/ContextProcessor/DateTimeProcessor.php (2)

22-30: Silence PHPMD for the intentionally unused recursiveProcessor.

This processor doesn’t recurse; suppress the warning locally.

     /**
      * @param \DateTimeInterface $value
      * @param callable(mixed): mixed $recursiveProcessor
      * @return string
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
      */
     public function process(mixed $value, callable $recursiveProcessor): mixed
     {
         return $value->format(\DateTimeInterface::ATOM);
     }

---

29-29: Optional: Use RFC3339_EXTENDED to retain sub-second precision.

If higher precision timestamps are useful for log correlation, prefer RFC3339_EXTENDED.

-        return $value->format(\DateTimeInterface::ATOM);
+        return $value->format(\DateTimeInterface::RFC3339_EXTENDED);

src/ContextProcessor/ResourceProcessor.php (2)

21-29: Suppress PHPMD for the unused recursiveProcessor (no recursion needed here).

     /**
      * @param resource $value
      * @param callable(mixed): mixed $recursiveProcessor
      * @return string
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
      */
     public function process(mixed $value, callable $recursiveProcessor): mixed
     {
         return \get_resource_type($value) . ' resource';
     }

---

26-29: Confirming PHP >= 8.1: get_resource_id() is available

composer.json specifies PHP >= 8.1, so get_resource_id (added in PHP 7.2) can be used safely. Including the resource ID can improve debugability.

Locations to update:

• src/ContextProcessor/ResourceProcessor.php (process method)

Proposed diff:

--- a/src/ContextProcessor/ResourceProcessor.php
+++ b/src/ContextProcessor/ResourceProcessor.php
@@ public function process(mixed $value, callable $recursiveProcessor): mixed
-        return \get_resource_type($value) . ' resource';
+        $type = \get_resource_type($value);
+        $id   = \get_resource_id($value);
+        return \sprintf('%s resource (%d)', $type, $id);

src/ContextProcessor/NullProcessor.php (1)

27-31: Return the given value and suppress the unused callback warning.

Returning $value expresses pass-through and eliminates one unused-parameter warning; suppress the other.

     /**
      * @param null $value
      * @param callable(mixed): mixed $recursiveProcessor
      * @return null
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
      */
     public function process(mixed $value, callable $recursiveProcessor): mixed
     {
-        // Null values are already suitable for logging
-        return null;
+        // Null values are already suitable for logging
+        return $value;
     }

src/ContextProcessor/FallbackProcessor.php (2)

17-21: Suppress PHPMD for intentionally unused parameter in canProcess

$value is intentionally unused because this processor is the last-resort handler. Suppress the warning to keep static analysis clean.

Apply this diff:

-    public function canProcess(mixed $value): bool
+    /**
+     * @SuppressWarnings("UnusedFormalParameter")
+     */
+    public function canProcess(mixed $value): bool
     {
         // This processor can handle anything as a last resort
         return true;
     }

---

23-30: Prefer get_debug_type and suppress PHPMD for unused $recursiveProcessor

• Suppress the unused-parameter warning for $recursiveProcessor.
• Consider \get_debug_type($value) for more informative type names (e.g., class names for objects, “float” instead of “double”). Not functionally required given upstream processors, but nicer as a final fallback.

Apply this diff:

-    /**
-     * @param callable(mixed): mixed $recursiveProcessor
-     * @return string
-     */
+    /**
+     * @param callable(mixed): mixed $recursiveProcessor
+     * @return string
+     * @SuppressWarnings("UnusedFormalParameter")
+     */
     public function process(mixed $value, callable $recursiveProcessor): mixed
     {
-        return \gettype($value);
+        return \get_debug_type($value);
     }

src/ContextProcessor/ScalarProcessor.php (1)

23-33: Suppress PHPMD for intentionally unused $recursiveProcessor

process returns the scalar as-is and doesn’t need the recursive callback. Suppress the warning to avoid noise from static analysis.

Apply this diff:

     /**
      * @param scalar $value
      * @param callable(mixed): mixed $recursiveProcessor
      * @return scalar
      */
-    public function process(mixed $value, callable $recursiveProcessor): mixed
+    /**
+     * @SuppressWarnings("UnusedFormalParameter")
+     */
+    public function process(mixed $value, callable $recursiveProcessor): mixed
     {
         // Scalar values are already suitable for logging
         return $value;
     }

src/ContextProcessor/StringableProcessor.php (1)

21-29: Suppress PHPMD for intentionally unused $recursiveProcessor

The recursive callback isn’t needed here since we directly cast to string. Suppress the warning.

Apply this diff:

     /**
      * @param \Stringable $value
      * @param callable(mixed): mixed $recursiveProcessor
      * @return string
      */
-    public function process(mixed $value, callable $recursiveProcessor): mixed
+    /**
+     * @SuppressWarnings("UnusedFormalParameter")
+     */
+    public function process(mixed $value, callable $recursiveProcessor): mixed
     {
         return (string) $value;
     }

tests/Unit/ContextProcessor/ArrayProcessorTest.php (2)

17-28: Avoid leaving open resources in data providers

Using fopen('php://memory', 'r') creates a resource that isn’t closed. Prefer tmpfile(), which is cleaned up automatically by PHP.

Apply this diff:

         return [
             'string' => ['not an array'],
             'integer' => [42],
             'float' => [3.14],
             'boolean' => [true],
             'null' => [null],
             'object' => [new \stdClass()],
-            'resource' => [\fopen('php://memory', 'r')],
+            'resource' => [\tmpfile()],
         ];

---

75-99: Strengthen the nested-array test and remove the unused $expected variable warning

Currently, $expected is unused and the assertion only checks for a key. Make the recursive processor transform arrays so we can assert the exact expected result.

Apply this diff:

         // Mock recursive processor that adds a prefix to strings
-        $recursiveProcessor = static function ($value) {
-            return \is_string($value) ? 'processed:' . $value : $value;
-        };
+        $recursiveProcessor = static function ($value) {
+            if (\is_array($value)) {
+                return 'processed:' . \serialize($value);
+            }
+            return \is_string($value) ? 'processed:' . $value : $value;
+        };
 
         $result = $this->processor->process($array, $recursiveProcessor);
 
         $expected = [
             'level1' => 'processed:' . \serialize(['level2' => ['value' => 'deep']]),
         ];
 
-        // Since the recursive processor is called on the nested array,
-        // we need to test that it was called correctly
-        $this->assertArrayHasKey('level1', $result);
+        // The nested array should be transformed by the recursive processor
+        $this->assertSame($expected, $result);

tests/Unit/ContextProcessor/ObjectProcessorTest.php (1)

17-28: Avoid leaking resources in data providers

The nonObjectProvider opens a stream resource that is never closed. Data providers are executed before the test and you don’t get a chance to fclose there, which can lead to handle leaks across the test run.

Apply this minimal change inside the provider and move the resource case to a dedicated test where you can open/close explicitly:

         return [
             'string' => ['not an object'],
             'integer' => [42],
             'float' => [3.14],
             'boolean' => [true],
             'null' => [null],
             'array' => [[]],
-            'resource' => [\fopen('php://memory', 'r')],
+            // resource case covered in a dedicated test to avoid leaking open handles
         ];

Then add this method elsewhere in the class to cover the resource case:

public function testCannotProcessResource(): void
{
    $h = \fopen('php://memory', 'r');
    try {
        $this->assertFalse($this->processor->canProcess($h));
    } finally {
        \fclose($h);
    }
}

tests/Unit/ContextProcessor/NullProcessorTest.php (1)

17-29: Prevent resource leaks in provider

As with the other test, the resource created in the data provider is never closed.

Remove the resource from the provider:

         return [
             'string' => ['test'],
             'integer' => [42],
             'float' => [3.14],
             'boolean true' => [true],
             'boolean false' => [false],
             'array' => [[]],
             'object' => [new \stdClass()],
-            'resource' => [\fopen('php://memory', 'r')],
+            // resource case is covered by a dedicated test to ensure proper closing
         ];

Then add a dedicated test method where you can open and close:

public function testCannotProcessResource(): void
{
    $h = \fopen('php://memory', 'r');
    try {
        $this->assertFalse($this->processor->canProcess($h));
    } finally {
        \fclose($h);
    }
}

tests/Unit/ContextProcessor/StringableProcessorTest.php (1)

17-29: Close the opened resource from the data provider

The provider opens a memory stream (Line 27) that is never closed in the test, leaking a resource. Close it in the test via a finally block.

     #[DataProvider('nonStringableProvider')]
     public function testCannotProcessNonStringable(mixed $value): void
     {
-        $this->assertFalse($this->processor->canProcess($value));
+        try {
+            $this->assertFalse($this->processor->canProcess($value));
+        } finally {
+            if (\is_resource($value)) {
+                \fclose($value);
+            }
+        }
     }

Also applies to: 43-47

tests/Unit/ContextProcessor/ScalarProcessorTest.php (2)

17-30: Close resource from data provider in canProcess test

The data provider opens a resource (Line 28) that isn’t closed, causing a leak when used in this test. Close it in a finally block.

     #[DataProvider('scalarValuesProvider')]
     public function testCanProcessScalarValues(mixed $value, bool $expected): void
     {
-        $this->assertSame($expected, $this->processor->canProcess($value));
+        try {
+            $this->assertSame($expected, $this->processor->canProcess($value));
+        } finally {
+            if (\is_resource($value)) {
+                \fclose($value);
+            }
+        }
     }

Also applies to: 32-36

---

17-30: Also close resource in process test

Same leak exists when the dataset is used in testProcessScalarValues. Close in a finally block.

     #[DataProvider('scalarValuesProvider')]
     public function testProcessScalarValues(mixed $value, bool $canProcess): void
     {
-        if ($canProcess) {
-            $recursiveProcessor = static fn($v) => $v;
-            $result = $this->processor->process($value, $recursiveProcessor);
-            $this->assertSame($value, $result);
-        } else {
-            $this->addToAssertionCount(1); // Skip non-scalar values
-        }
+        try {
+            if ($canProcess) {
+                $recursiveProcessor = static fn($v) => $v;
+                $result = $this->processor->process($value, $recursiveProcessor);
+                $this->assertSame($value, $result);
+            } else {
+                $this->addToAssertionCount(1); // Skip non-scalar values
+            }
+        } finally {
+            if (\is_resource($value)) {
+                \fclose($value);
+            }
+        }
     }

Also applies to: 38-48

tests/Unit/ContextProcessor/ResourceProcessorTest.php (1)

69-88: Rename and simplify: not actually testing cURL resource

On PHP 8+, curl_init returns CurlHandle (object), and this test ultimately processes a stream resource, not cURL. The extension gate and curl handle are unnecessary. Rename the test and drop cURL code.

-    public function testProcessCurlResource(): void
-    {
-        if (!\extension_loaded('curl')) {
-            $this->markTestSkipped('cURL extension not available');
-        }
-
-        $curlHandle = \curl_init();
-
-        // In PHP 8+, curl_init returns CurlHandle object, not resource
-        // Let's test with a different resource type that's consistently a resource
-        $resource = \fopen('data://text/plain;base64,SGVsbG8gV29ybGQ=', 'r');
-        $recursiveProcessor = static fn($v) => $v;
-
-        $result = $this->processor->process($resource, $recursiveProcessor);
-
-        \fclose($resource);
-        \curl_close($curlHandle);
-
-        $this->assertSame('stream resource', $result);
-    }
+    public function testProcessDataStreamResource(): void
+    {
+        $resource = \fopen('data://text/plain;base64,SGVsbG8gV29ybGQ=', 'r');
+        $recursiveProcessor = static fn($v) => $v;
+        $result = $this->processor->process($resource, $recursiveProcessor);
+        \fclose($resource);
+        $this->assertSame('stream resource', $result);
+    }

src/ContextProcessor/ContextProcessorManager.php (1)

65-75: Optional: add recursion depth guard to prevent runaway processing

Self-referential arrays/objects can cause infinite recursion. Adding a max-depth cap is a pragmatic safety net.

-    public function processValue(mixed $value): mixed
+    private int $maxDepth = 10;
+
+    public function processValue(mixed $value, int $depth = 0): mixed
     {
+        if ($depth >= $this->maxDepth) {
+            return '*max-depth*';
+        }
         foreach ($this->processors as $processor) {
             if ($processor->canProcess($value)) {
-                return $processor->process($value, [$this, 'processValue']);
+                $recursive = function (mixed $v) use ($depth) {
+                    return $this->processValue($v, $depth + 1);
+                };
+                return $processor->process($value, $recursive);
             }
         }
 
         // This should never happen due to FallbackProcessor, but just in case
         return \gettype($value);
     }

Note: No changes needed where processValue is called—existing calls will start at depth 0.

tests/Unit/ContextProcessor/FallbackProcessorTest.php (2)

17-41: Prefer deterministic cleanup over register_shutdown_function for test-created resources.

Using register_shutdown_function to close the data-provider resource works, but it’s global and can hide leaks. Consider closing the handle in a class-level tearDownAfterClass or creating/closing the resource within individual tests that need it to keep lifecycle explicit.

Example approach using tearDownAfterClass:

private static $resource;

public static function allTypesProvider(): array
{
    self::$resource = \fopen('php://memory', 'r');
    return [
        // ...
        'resource' => [self::$resource, 'resource'],
    ];
}

public static function tearDownAfterClass(): void
{
    if (\is_resource(self::$resource)) {
        \fclose(self::$resource);
    }
}

---

59-70: Assert that the closed resource is actually closed to avoid false confidence.

Minor robustness: after fclose($resource), add an assertion that is_resource($resource) is false (where applicable) before proceeding, to make the test intent explicit. It won’t harm environments where PHP still reports it as a resource, since you’re only asserting the result type is a string.

-        \fclose($resource);
+        \fclose($resource);
+        // Depending on PHP version, this may be false or still report as resource.
+        $this->assertIsString($this->processor->process($resource, static fn($v) => $v));

tests/Unit/RpcLoggerTest.php (4)

546-559: Silence PHPMD warnings for unused $recursiveProcessor in test stubs.

These stubs don’t use the recursive processor; make that explicit to satisfy static analysis.

Apply this diff:

             public function process(mixed $value, callable $recursiveProcessor): mixed
             {
+                unset($recursiveProcessor); // unused in this test stub
                 // Mask email for privacy
                 $parts = \explode('@', $value);
                 return \substr($parts[0], 0, 2) . '***@' . $parts[1];
             }

---

586-601: Silence PHPMD warnings for unused $recursiveProcessor in URL processor stub.

             public function process(mixed $value, callable $recursiveProcessor): mixed
             {
+                unset($recursiveProcessor); // unused in this test stub
                 $parsed = \parse_url($value);
                 return [
                     'scheme' => $parsed['scheme'] ?? null,
                     'host' => $parsed['host'] ?? null,
                     'path' => $parsed['path'] ?? null,
                 ];
             }

---

604-614: Silence PHPMD warnings for unused $recursiveProcessor in CC processor stub.

             public function process(mixed $value, callable $recursiveProcessor): mixed
             {
+                unset($recursiveProcessor); // unused in this test stub
                 return '****-****-****-' . \substr($value, -4);
             }

---

485-503: Ensure resource creation succeeds to avoid undefined behavior on fopen failure.

fopen() may return false; guard the test to fail fast or skip if the resource can’t be created.

-        $resource = \fopen('php://memory', 'r');
+        $resource = \fopen('php://memory', 'r');
+        $this->assertIsResource($resource, 'Failed to create test resource');

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

tests/Unit/ContextProcessor/ContextProcessorManagerTest.php (1)

81-95: Add regression tests for cyclic references to prevent infinite recursion

Echoing the earlier note: arrays/objects can self‑reference and will currently recurse unbounded. Add tests for self‑referential arrays and mutually‑referencing objects; then implement a recursion guard in the manager (seen-set + max depth).

I can provide a ready-to-merge guard for ContextProcessorManager plus tests if you’d like.

src/RpcLogger.php (1)

52-56: Potential TypeError: cast Stringable messages to string consistently (duplicate of prior review)

Some branches pass $message as \Stringable to AppLogger, which likely expects string. This can throw under strict types. Cast once and reuse to avoid per-branch discrepancies.

Apply this diff to cast once and remove per-branch casts:

     // Process context data for structured logging using the processor manager
     $processedContext = $this->contextProcessor->processContext($context);
+    $message = (string) $message;

     match ($normalizedLevel) {
         PsrLogLevel::EMERGENCY,
         PsrLogLevel::ALERT,
         PsrLogLevel::CRITICAL,
-        PsrLogLevel::ERROR => $this->logger->error($message, $processedContext),
-        PsrLogLevel::WARNING => $this->logger->warning($message, $processedContext),
-        PsrLogLevel::NOTICE, PsrLogLevel::INFO => $this->logger->info((string) $message, $processedContext),
-        'log' => $this->logger->log((string) $message, $processedContext),
-        PsrLogLevel::DEBUG => $this->logger->debug($message, $processedContext),
+        PsrLogLevel::ERROR => $this->logger->error($message, $processedContext),
+        PsrLogLevel::WARNING => $this->logger->warning($message, $processedContext),
+        PsrLogLevel::NOTICE, PsrLogLevel::INFO => $this->logger->info($message, $processedContext),
+        'log' => $this->logger->log($message, $processedContext),
+        PsrLogLevel::DEBUG => $this->logger->debug($message, $processedContext),
     };

tests/Unit/ContextProcessor/ThrowableProcessorTest.php (1)

84-95: Fix brittle assertion for anonymous exception class name.

get_class() for an anonymous class produces a name like "class@anonymous..." (parent class name is not guaranteed to be present). Assert the generic marker instead of "Exception@anonymous".

Apply:

-        $this->assertTrue(\str_contains($result['class'], 'Exception@anonymous'));
+        $this->assertStringContainsString('@anonymous', $result['class']);

tests/Unit/RpcLoggerTest.php (3)

544-581: Custom processor precedence is ineffective; BuiltInTypeProcessor will preempt strings. Prepend or assert processed output.

ContextProcessorManager registers BuiltInTypeProcessor first; addProcessor() appends. Your email processor won’t run for strings because BuiltInTypeProcessor short-circuits first. Also, the test doesn’t assert that masking actually occurred.

Recommended changes:

• Introduce a prepend API on ContextProcessorManager and use it in tests.
• Assert the processed context by invoking $processorManager->processContext($context) directly (in addition to the existing RPC assertions).

Patch the test:

-        // Create processor manager with custom processor added first
-        $processorManager = new ContextProcessorManager();
-        $processorManager->addProcessor($emailProcessor);
+        // Create processor manager and prepend the custom processor so it runs before defaults
+        $processorManager = new ContextProcessorManager();
+        $processorManager->addProcessorFirst($emailProcessor);

         // Create logger with custom processor manager
         $logger = new RpcLogger($this->appLogger, $processorManager);

         $context = [
             'user_email' => '[email protected]',
             'admin_email' => '[email protected]',
             'regular_string' => 'not an email',
             'user_id' => 123,
         ];

+        // Assert transformation happened at the manager level
+        $processed = $processorManager->processContext($context);
+        $this->assertSame('jo***@example.com', $processed['user_email']);
+        $this->assertSame('ad***@company.org', $processed['admin_email']);
+        $this->assertSame('not an email', $processed['regular_string']);
+        $this->assertSame(123, $processed['user_id']);
+
         $logger->info('User action performed', $context);

Suppress PHPMD “UnusedFormalParameter” for anonymous processor’s process() method:

-            public function process(mixed $value, callable $recursiveProcessor): mixed
+            /**
+             * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+             */
+            public function process(mixed $value, callable $recursiveProcessor): mixed
             {

Manager addition (outside this file):

--- a/src/Internal/ContextProcessor/ContextProcessorManager.php
+++ b/src/Internal/ContextProcessor/ContextProcessorManager.php
@@ class ContextProcessorManager
     public function addProcessor(ContextProcessorInterface $processor): void
     {
         $this->processors[] = $processor;
     }
+
+    /**
+     * Prepend a processor so it runs before defaults.
+     */
+    public function addProcessorFirst(ContextProcessorInterface $processor): void
+    {
+        \array_unshift($this->processors, $processor);
+    }

Quick verification script to confirm current precedence:

#!/bin/bash
# Expectation: BuiltInTypeProcessor is registered before others, and addProcessor appends.
rg -nC2 'class ContextProcessorManager|registerDefaultProcessors|function\s+addProcessor\(' src

Also applies to: 561-564, 575-581

---

583-635: Multiple custom processors have the same precedence issue; also not asserting actual transformation.

URL and CC processors are appended after defaults, so strings never reach them. Strengthen the test by prepending processors and asserting processed shapes via the manager.

Apply:

-        $processorManager = new ContextProcessorManager();
-        $processorManager->addProcessor($urlProcessor);
-        $processorManager->addProcessor($ccProcessor);
+        $processorManager = new ContextProcessorManager();
+        $processorManager->addProcessorFirst($urlProcessor);
+        $processorManager->addProcessorFirst($ccProcessor);

Add explicit assertions:

-        $logger = new RpcLogger($this->appLogger, $processorManager);
+        $logger = new RpcLogger($this->appLogger, $processorManager);

         $context = [
             'website' => 'https://example.com/path/to/resource',
             'payment_card' => '1234-5678-9012-3456',
             'regular_data' => 'normal string',
             'amount' => 99.99,
         ];

+        $processed = $processorManager->processContext($context);
+        $this->assertSame(
+            ['scheme' => 'https', 'host' => 'example.com', 'path' => '/path/to/resource'],
+            $processed['website']
+        );
+        $this->assertSame('****-****-****-3456', $processed['payment_card']);
+        $this->assertSame('normal string', $processed['regular_data']);
+        $this->assertSame(99.99, $processed['amount']);

Suppress PHPMD in the two anonymous processors:

-            public function process(mixed $value, callable $recursiveProcessor): mixed
+            /**
+             * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+             */
+            public function process(mixed $value, callable $recursiveProcessor): mixed
             {

(repeat for the credit-card processor)

Also applies to: 616-619, 629-635

---

656-699: Ordering test doesn’t validate ordering due to BuiltInTypeProcessor handling ints first. Prepend and assert via manager.

As written, your int processors won’t run. Prepend them and assert that the first one wins by inspecting the manager’s output.

Apply:

-        $processorManager = new ContextProcessorManager();
-        $processorManager->addProcessor($firstProcessor);  // Added first, should be used
-        $processorManager->addProcessor($secondProcessor); // Added second, should be skipped
+        $processorManager = new ContextProcessorManager();
+        $processorManager->addProcessorFirst($firstProcessor);  // Prepend to run before BuiltInTypeProcessor
+        $processorManager->addProcessorFirst($secondProcessor); // Still after $firstProcessor

Assert ordering effect explicitly:

-        $context = ['number' => 42];
+        $context = ['number' => 42];
+        $processed = $processorManager->processContext($context);
+        $this->assertSame('first:42', $processed['number']);
         $logger->debug('Ordering test', $context);

Suppress PHPMD in both anonymous processors:

-            public function process(mixed $value, callable $recursiveProcessor): mixed
+            /**
+             * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+             */
+            public function process(mixed $value, callable $recursiveProcessor): mixed
             {

Also applies to: 683-686, 689-699

composer.json (1)

46-46: Split coverage run into a separate script to keep composer test fast and xdebug-agnostic

Always enabling Xdebug slows local/CI runs and fails if Xdebug isn’t installed. Recommend keeping test lean and adding a dedicated test:coverage script.

Apply:

   "scripts": {
     "cs:diff": "php-cs-fixer fix --dry-run -v --diff --show-progress dots",
     "cs:fix": "php-cs-fixer fix -v",
-    "test": "XDEBUG_MODE=coverage phpunit",
+    "test": "phpunit",
+    "test:coverage": "php -d xdebug.mode=coverage phpunit",
     "psalm": "psalm"
   },

src/Internal/ContextProcessor/StringableProcessor.php (2)

16-16: Make the class final since it’s internal

Prevents unintended extension and allows future internal changes without BC guarantees.

-class StringableProcessor implements ContextProcessorInterface
+final class StringableProcessor implements ContextProcessorInterface

---

23-31: Suppress PHPMD false-positive for unused $recursiveProcessor

Signature is mandated by the interface; this processor doesn’t need recursion. Suppress the warning locally.

     /**
      * @param \Stringable $value
      * @param callable(mixed): mixed $recursiveProcessor
      * @return string
+     * @SuppressWarnings("UnusedFormalParameter")
      */
     public function process(mixed $value, callable $recursiveProcessor): mixed
     {
         return (string) $value;
     }

src/Internal/ContextProcessor/DateTimeProcessor.php (3)

17-17: Consider final for internal class

Same rationale as other internal processors.

-class DateTimeProcessor implements ContextProcessorInterface
+final class DateTimeProcessor implements ContextProcessorInterface

---

24-32: Suppress PHPMD unused-parameter warning on $recursiveProcessor

Processor doesn’t recurse; keep interface but silence the false-positive.

     /**
      * @param \DateTimeInterface $value
      * @param callable(mixed): mixed $recursiveProcessor
      * @return string
+     * @SuppressWarnings("UnusedFormalParameter")
      */
     public function process(mixed $value, callable $recursiveProcessor): mixed
     {
         return $value->format(\DateTimeInterface::ATOM);
     }

---

29-32: Optional: include microseconds for higher-resolution logs

If you want sub-second precision, consider RFC3339_EXTENDED.

-        return $value->format(\DateTimeInterface::ATOM);
+        return $value->format(\DateTimeInterface::RFC3339_EXTENDED);

If compatibility with existing consumers relies on ATOM, keep current behavior.

src/Internal/ContextProcessor/ObjectProcessor.php (2)

17-17: Mark as final

Internal utility that shouldn’t be extended externally.

-class ObjectProcessor implements ContextProcessorInterface
+final class ObjectProcessor implements ContextProcessorInterface

---

48-50: Fallback to class name is reasonable; consider JsonSerializable later

Returning class name when no public properties exist is a sensible default. As a future enhancement, you might special-case JsonSerializable to serialize its payload, if present.

src/Internal/ContextProcessor/ResourceProcessor.php (3)

16-16: Make class final

Consistent with other internal processors; avoids accidental inheritance.

-class ResourceProcessor implements ContextProcessorInterface
+final class ResourceProcessor implements ContextProcessorInterface

---

23-31: Suppress PHPMD unused-parameter warning

Same interface constraint; suppress locally.

     /**
      * @param resource $value
      * @param callable(mixed): mixed $recursiveProcessor
      * @return string
+     * @SuppressWarnings("UnusedFormalParameter")
      */
     public function process(mixed $value, callable $recursiveProcessor): mixed
     {
         return \get_resource_type($value) . ' resource';
     }

---

30-31: Nit: unify resource string format (optional)

Some teams prefer resource(type) for quick scanning. Purely stylistic; current output is fine.

-        return \get_resource_type($value) . ' resource';
+        return 'resource(' . \get_resource_type($value) . ')';

src/Internal/ContextProcessor/ContextProcessorInterface.php (1)

25-32: Nit: tighten the contract around the recursive callback and behavior

Consider documenting behavioral guarantees to guide implementors and help static analyzers:

• State that processors should be side‑effect free and avoid throwing (or document expected exceptions).
• Name and describe the recursion callback as a stable “processValue” contract to make intent explicit.

Example doc enhancement:

     /**
      * Process the value and return a serializable representation.
      *
      * @param TValue $value The value to process
-     * @param callable(mixed): mixed $recursiveProcessor Function to process nested values recursively
+     * @param callable(mixed): mixed $recursiveProcessor Recursor provided by the manager;
+     *        must be used to process nested values. Implementations should be side‑effect free
+     *        and avoid throwing; return a best‑effort representation instead.
      * @return TProcessed Processed value suitable for logging
      */

src/Internal/ContextProcessor/FallbackProcessor.php (2)

17-17: Make internal processors final

These classes are internal implementation details; marking them final eases refactoring and enables engine optimizations.

-class FallbackProcessor implements ContextProcessorInterface
+final class FallbackProcessor implements ContextProcessorInterface

---

19-23: Silence PHPMD UnusedFormalParameter warnings intentionally

In canProcess the parameter is unused by design; in process the recursive callback is unused by design. Suppress these to keep CI noise down.

 class FallbackProcessor implements ContextProcessorInterface
 {
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
     public function canProcess(mixed $value): bool
     {
         // This processor can handle anything as a last resort
         return true;
     }
 
     /**
      * @param callable(mixed): mixed $recursiveProcessor
      * @return string
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
      */
     public function process(mixed $value, callable $recursiveProcessor): mixed
     {
         return \gettype($value);
     }
 }

Also applies to: 25-33

src/Internal/ContextProcessor/ThrowableProcessor.php (2)

17-17: Make internal processors final

Same rationale as other processors.

-class ThrowableProcessor implements ContextProcessorInterface
+final class ThrowableProcessor implements ContextProcessorInterface

---

24-39: Leverage the recursive processor for chained exceptions

Including previous exceptions makes the structured payload complete and also removes the “unused parameter” warning. Suggest processing the chain via the supplied recursor.

     public function process(mixed $value, callable $recursiveProcessor): mixed
     {
-        return [
+        $previous = $value->getPrevious();
+
+        return [
             'class' => \get_class($value),
             'message' => $value->getMessage(),
             'code' => $value->getCode(),
             'file' => $value->getFile(),
             'line' => $value->getLine(),
-            'trace' => $value->getTraceAsString(),
+            'trace' => $value->getTraceAsString(),
+            // Include previous exception chain (if any)
+            'previous' => $previous !== null ? $recursiveProcessor($previous) : null,
         ];
     }

tests/Unit/ContextProcessor/ObjectProcessorTest.php (1)

44-49: PHPMD unused private fields in test fixtures are intentional

The anonymous class’ private field is present to verify exclusion of non‑public props. Consider suppressing PHPMD for tests or configuring the ruleset to ignore tests to avoid false positives.

tests/Unit/ContextProcessor/ContextProcessorManagerTest.php (2)

122-145: Precedence control for custom processors

This test demonstrates that custom processors added after defaults can’t override built‑ins (strings handled by BuiltInTypeProcessor). Consider supporting a “prepend” registration to enable targeted overrides.

Example API and usage:

-    public function addProcessor(ContextProcessorInterface $processor): void
+    public function addProcessor(ContextProcessorInterface $processor): void
     {
         $this->processors[] = $processor;
     }
+
+    /**
+     * Register a processor with higher priority (checked before existing ones).
+     */
+    public function prependProcessor(ContextProcessorInterface $processor): void
+    {
+        \array_unshift($this->processors, $processor);
+    }

Then in the test:

-        $this->manager->addProcessor($customProcessor);
+        $this->manager->prependProcessor($customProcessor);

And assert the transformed value accordingly.

---

25-38: Optional: add a test asserting numeric keys become strings

processContext stringifies keys; add a case like ['0' => 'a'] and [0 => 'a'] to ensure stable behavior and set expectations in tests.

src/RpcLogger.php (1)

22-26: Constructor injection of ContextProcessorManager looks good

Optional enhancement: rename the property to $contextProcessorManager for clarity (it holds a manager, not a single processor). Not a blocker.

tests/Unit/ContextProcessor/BuiltInTypeProcessorTest.php (1)

17-32: Avoid leaking resources from the data provider

The provider opens a stream that is never closed. Wrap the resource creation in a closure and close it in the test after the assertion.

Apply this diff:

     public static function builtInTypeValuesProvider(): array
     {
         return [
@@
-            'resource' => [\fopen('php://memory', 'r'), false],
+            // Defer resource creation to the test to ensure proper closing
+            'resource' => [static fn() => \fopen('php://memory', 'r'), false],
         ];
     }
@@
-    public function testCanProcessBuiltInTypes(mixed $value, bool $expected): void
+    public function testCanProcessBuiltInTypes(mixed $value, bool $expected): void
     {
-        $this->assertSame($expected, $this->processor->canProcess($value));
+        if (\is_callable($value)) {
+            $value = $value();
+        }
+        try {
+            $this->assertSame($expected, $this->processor->canProcess($value));
+        } finally {
+            if (\is_resource($value)) {
+                \fclose($value);
+            }
+        }
     }

tests/Unit/ContextProcessor/ResourceProcessorTest.php (3)

43-53: Use try/finally to guarantee stream closure on assertion failures

Minor hygiene to prevent leaks if an assertion throws.

     public function testProcessStreamResource(): void
     {
-        $resource = \fopen('php://memory', 'r');
-        $recursiveProcessor = static fn($v) => $v;
-
-        $result = $this->processor->process($resource, $recursiveProcessor);
-
-        \fclose($resource);
-
-        $this->assertSame('stream resource', $result);
+        $resource = \fopen('php://memory', 'r');
+        try {
+            $recursiveProcessor = static fn($v) => $v;
+            $result = $this->processor->process($resource, $recursiveProcessor);
+            $this->assertSame('stream resource', $result);
+        } finally {
+            \fclose($resource);
+        }
     }

---

55-67: Same: ensure file handle cleanup via try/finally

Keeps temp file and handle lifecycle safe even on failures.

     public function testProcessFileResource(): void
     {
         $tempFile = \tempnam(\sys_get_temp_dir(), 'test');
-        $resource = \fopen($tempFile, 'w');
-        $recursiveProcessor = static fn($v) => $v;
-
-        $result = $this->processor->process($resource, $recursiveProcessor);
-
-        \fclose($resource);
-        \unlink($tempFile);
-
-        $this->assertSame('stream resource', $result);
+        $resource = \fopen($tempFile, 'w');
+        try {
+            $recursiveProcessor = static fn($v) => $v;
+            $result = $this->processor->process($resource, $recursiveProcessor);
+            $this->assertSame('stream resource', $result);
+        } finally {
+            \fclose($resource);
+            \unlink($tempFile);
+        }
     }

---

69-88: Tidy up cURL test: ensure handles are always closed

Handles both CurlHandle object (PHP 8+) and resource cleanup deterministically.

     public function testProcessCurlResource(): void
     {
         if (!\extension_loaded('curl')) {
             $this->markTestSkipped('cURL extension not available');
         }
 
-        $curlHandle = \curl_init();
-
-        // In PHP 8+, curl_init returns CurlHandle object, not resource
-        // Let's test with a different resource type that's consistently a resource
-        $resource = \fopen('data://text/plain;base64,SGVsbG8gV29ybGQ=', 'r');
-        $recursiveProcessor = static fn($v) => $v;
-
-        $result = $this->processor->process($resource, $recursiveProcessor);
-
-        \fclose($resource);
-        \curl_close($curlHandle);
-
-        $this->assertSame('stream resource', $result);
+        $curlHandle = \curl_init();
+        $resource = \fopen('data://text/plain;base64,SGVsbG8gV29ybGQ=', 'r');
+        try {
+            $recursiveProcessor = static fn($v) => $v;
+            $result = $this->processor->process($resource, $recursiveProcessor);
+            $this->assertSame('stream resource', $result);
+        } finally {
+            \fclose($resource);
+            if (\is_resource($curlHandle) || $curlHandle !== null) {
+                \curl_close($curlHandle);
+            }
+        }
     }

src/Internal/ContextProcessor/ContextProcessorManager.php (1)

64-77: processValue() is now redundant if the guard is inlined into processContext

Either:

• keep processValue() as a thin wrapper that calls the guarded closure (for tests using processValue directly), or
• deprecate processValue() in favor of the guarded closure pattern.

If tests call processValue() directly, provide a compatibility wrapper:

-    public function processValue(mixed $value): mixed
+    public function processValue(mixed $value): mixed
     {
-        foreach ($this->processors as $processor) {
-            if ($processor->canProcess($value)) {
-                return $processor->process($value, [$this, 'processValue']);
-            }
-        }
-        // This should never happen due to FallbackProcessor, but just in case
-        return \gettype($value);
+        // Compatibility path without guard; consider routing via processContext for safety
+        foreach ($this->processors as $processor) {
+            if ($processor->canProcess($value)) {
+                return $processor->process($value, [$this, 'processValue']);
+            }
+        }
+        return \gettype($value);
     }

Up to you whether to route it through the guarded path; if you do, annotate the potential performance overhead.

Would you like me to adapt tests (ContextProcessorManagerTest et al.) if you choose to route processValue through the guarded path?

tests/Unit/RpcLoggerTest.php (1)

466-470: Suppress PHPMD false-positive for intentionally unused private/protected props in object-fixture.

Private/protected props are present by design to validate that ObjectProcessor only extracts public properties. PHPMD reports UnusedPrivateField here. Add an inline suppression on the private property to keep static analysis green without altering the fixture’s intent.

-            private string $privateProp = 'private value';
+            /** @SuppressWarnings(PHPMD.UnusedPrivateField) */
+            private string $privateProp = 'private value';

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

src/Internal/ContextProcessor/StringableProcessor.php (1)

18-21: Logic is correct: handles all Stringable objects via cast

canProcess and (string)$value are precise and side-effect free. No issues.

src/Internal/ContextProcessor/DateTimeProcessor.php (1)

19-22: LGTM: robust DateTime detection

Covers DateTime and DateTimeImmutable via DateTimeInterface. Clean and predictable.

src/Internal/ContextProcessor/ResourceProcessor.php (1)

18-21: Resource detection is correct

is_resource is the right gate; behavior is deterministic even for closed resources.

src/Internal/ContextProcessor/ContextProcessorInterface.php (1)

7-17: Interface shape and documentation look solid

Clear internal contract, succinct docs, and practical generics for static analyzers. No issues.

src/Internal/ContextProcessor/ThrowableProcessor.php (1)

31-38: Consider configurable trace verbosity for PII/sizing control

Trace/file/line often contain file paths and can be large. If this is emitted in prod logs, add a way (config flag or alternate processor) to omit or truncate these fields.

Do you want me to sketch a minimal “SafeThrowableProcessor” variant and corresponding tests?

src/RpcLogger.php (1)

45-47: Nice: context is processed via ContextProcessorManager before dispatch

This is the right place to normalize/serialize context once, keeping the switch clean.

src/Internal/ContextProcessor/BuiltInTypeProcessor.php (2)

22-25: Good coverage of built-in types with fast-path check

canProcess correctly short-circuits for null|scalar|array, keeping the common path cheap.

---

34-53: Array recursion is correct; preserve keys and delegate via callback

Implementation is clean and allocates a fresh array. No change required.

tests/Unit/ContextProcessor/BuiltInTypeProcessorTest.php (1)

68-101: Nice recursive test; mirrors manager callback behavior

The nested array test demonstrates the contract expected by processors when delegating via the recursive callback.

src/Internal/ContextProcessor/ContextProcessorManager.php (1)

83-101: Order of default processors is sensible and future-proof

Built-in types first, specifics next, resource, generic object, then fallback. Matches expected hit rates and specificity.

tests/Unit/ContextProcessor/ThrowableProcessorTest.php (4)

17-26: Solid coverage of Throwable variants in provider.

Representative set (Exception, RuntimeException, InvalidArgumentException, Error, TypeError) makes canProcess() behavior explicit. No changes needed.

---

28-38: Good negative cases for canProcess().

Covers common non-throwable inputs including null and arrays. Looks good.

---

52-69: End-to-end structure assertions are appropriate.

Validates class/message/code and basic types for file/line/trace for both Exception and Error. These will catch regressions in ThrowableProcessor::process().

Also applies to: 71-82

---

97-101: Test fixture initialization is clear.

setUp() constructs a fresh processor per test. Good.

tests/Unit/RpcLoggerTest.php (2)

359-376: Broad context coverage looks good.

These tests exercise scalars, DateTimeInterface, Throwable, Stringable, nested arrays, plain objects, resources, and mixed contexts, asserting the correct RPC method selection and payload envelope type. This gives confidence that RpcLogger delegates correctly once ContextProcessorManager is involved.

Also applies to: 378-396, 397-413, 415-436, 438-461, 463-483, 485-503, 505-542

---

14-16: New imports align with the processor-based context pipeline.

Importing ContextProcessorInterface and ContextProcessorManager here is appropriate for the added tests.

src/Internal/ObjectProcessor.php (1)

8-8: Fix doc typo for clarity.
The summary line currently says “arra” instead of “array”. Please correct the typo to keep the PHPDoc accurate.

- * Converts an object into a scalar or an arra for serializable logger context.
+ * Converts an object into a scalar or an array for serializable logger context.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Internal/ContextProcessor/FallbackProcessor.php (2)

23-25: Add precise docblocks to fix mixed assignment warnings.

Annotate the shape for Psalm/PhpStan.

-        $result = ['@class' => $value::class] + \get_object_vars($value);
+        /** @var array<string, mixed> $result */
+        $result = ['@class' => $value::class] + \get_object_vars($value);

Optionally, add @psalm-return array<string, mixed> to the method.

---

25-25: Consider standardizing the key name with ThrowableProcessor.

This uses '@Class' while ThrowableProcessor uses 'class'. Pick one for consistency (prefer 'class' unless '@' is intentional for namespacing).

src/RpcLogger.php (2)

20-26: Type the callable and construct the closure explicitly for analyzers.

Help static analysis by documenting the callable signature.

-    private readonly \Closure $objectProcessor;
+    /** @var \Closure(mixed): mixed */
+    private readonly \Closure $objectProcessor;
@@
-        $this->objectProcessor = ($processor ?? DefaultProcessor::createDefault())(...);
+        /** @var \Closure(mixed): mixed $callable */
+        $callable = ($processor ?? DefaultProcessor::createDefault())(...);
+        $this->objectProcessor = $callable;

---

35-56: Cast message once; remove per-branch casts.

Guarantee string messages under strict types and reduce duplication.

     public function log($level, \Stringable|string $message, array $context = []): void
     {
+        $message = (string) $message;
@@
-            PsrLogLevel::ERROR => $this->logger->error($message, $processedContext),
-            PsrLogLevel::WARNING => $this->logger->warning($message, $processedContext),
-            PsrLogLevel::NOTICE, PsrLogLevel::INFO => $this->logger->info((string) $message, $processedContext),
-            'log' => $this->logger->log((string) $message, $processedContext),
-            PsrLogLevel::DEBUG => $this->logger->debug($message, $processedContext),
+            PsrLogLevel::ERROR => $this->logger->error($message, $processedContext),
+            PsrLogLevel::WARNING => $this->logger->warning($message, $processedContext),
+            PsrLogLevel::NOTICE, PsrLogLevel::INFO => $this->logger->info($message, $processedContext),
+            'log' => $this->logger->log($message, $processedContext),
+            PsrLogLevel::DEBUG => $this->logger->debug($message, $processedContext),

tests/Unit/RpcLoggerTest.php (9)

360-377: These scalar-context tests don’t validate processing outcome.

They only assert call count and payload type. Add an assertion that the scalar values survive unchanged to the payload’s context map (e.g., via a test double that exposes context), otherwise the test can’t catch regressions.

---

379-396: DateTime context: assert formatted value if possible.

If you can access the payload’s context, assert ATOM formatting for both DateTime and DateTimeImmutable. Otherwise, this test won’t detect formatter regressions.

---

398-414: Throwable context: assert shape (class/message/code/trace) if accessible.

Strengthen by asserting the serialized keys to detect breaking changes in ThrowableProcessor.

---

416-437: Stringable context: verify casted string landed in context.

If payload allows, assert 'user' => 'Custom stringable object'. Helps validate StringableProcessor.

---

439-462: Nested arrays: assert deep preservation.

Consider asserting a deep key (e.g., ['level1']['level2']['level3']['number'] === 123) in the processed context.

---

464-484: Object context: clarify visibility expectations.

Fallback uses get_object_vars and will include only accessible/public props. Add an assertion for presence of publicProp and absence of private/protected if you can read the context.

---

486-504: Resource context: good cleanup; consider asserting rendered type.

You close the resource—good. If accessible, assert 'file_handle' => 'stream resource'.

---

506-543: Mixed complex context: add at least one ground-truth assertion.

E.g., ensure InvalidArgumentException serialized and DateTime formatted. Otherwise, this test duplicates earlier coverage without validating transformation.

---

583-635: Same issue for URL/CC processors; also missing assertions of transformed context.

These processors target strings and won’t be reached. Strengthen tests by asserting URL parts and masked card if/when the pipeline supports scalar processors.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tests/Unit/Context/ObjectProcessor/ThrowableProcessorTest.php (1)

79-90: Fix brittle assertion for anonymous exception class naming.

The assertion str_contains($result['class'], 'Exception@anonymous') is fragile. PHP's get_class() for anonymous classes returns a name like class@anonymous\x00... (not Exception@anonymous), so this assertion may fail.

Apply this fix:

-        $this->assertTrue(\str_contains($result['class'], 'Exception@anonymous'));
+        $this->assertStringContainsString('@anonymous', $result['class']);

src/Context/ObjectProcessor/FallbackProcessor.php (1)

26-32: Fix recursion + mixed assignments: avoid by-ref loop and skip after unset.

Current by-ref iteration reprocesses removed self-references and leaks the reference; also triggers Psalm MixedAssignment. Refactor as key-based loop and continue after unset.

-        $result = ['@class' => $value::class] + \get_object_vars($value);
-        foreach ($result as $k => &$v) {
-            if ($v === $value) {
-                unset($result[$k]);
-            }
-
-            $v = $processor($v);
-        }
+        /** @var array<string, mixed> $result */
+        $result = ['@class' => $value::class] + \get_object_vars($value);
+        foreach (\array_keys($result) as $k) {
+            $v = $result[$k];
+            if ($v === $value) {
+                unset($result[$k]);
+                continue;
+            }
+            $result[$k] = $processor($v);
+        }

src/RpcLogger.php (1)

52-56: Cast message for all branches; drop unsupported 'log' level.

Avoid TypeError with \Stringable and keep PSR-3 levels only.

-            PsrLogLevel::ERROR => $this->logger->error($message, $processedContext),
-            PsrLogLevel::WARNING => $this->logger->warning($message, $processedContext),
-            PsrLogLevel::NOTICE, PsrLogLevel::INFO => $this->logger->info((string) $message, $processedContext),
-            'log' => $this->logger->log((string) $message, $processedContext),
-            PsrLogLevel::DEBUG => $this->logger->debug($message, $processedContext),
+            PsrLogLevel::ERROR => $this->logger->error($message, $processedContext),
+            PsrLogLevel::WARNING => $this->logger->warning($message, $processedContext),
+            PsrLogLevel::NOTICE, PsrLogLevel::INFO => $this->logger->info($message, $processedContext),
+            PsrLogLevel::DEBUG => $this->logger->debug($message, $processedContext),

tests/Unit/RpcLoggerTest.php (3)

545-581: Custom email processor will never execute.

The email processor checks for string values (line 549), but DefaultProcessor only invokes object processors (lines 51-57 in src/Context/DefaultProcessor.php). Strings are scalars, so this processor is never called and email masking doesn't happen. The test only verifies an RPC call occurred, not that masking worked.

To fix, either:

1. Wrap email strings in value objects (e.g., Email class implementing Stringable) so the object processor pipeline can handle them, or
2. Extend the design to support scalar processors alongside object processors.

For option 1, add to the test:

// Before line 563
class Email implements \Stringable {
    public function __construct(private string $email) {}
    public function __toString(): string { return $this->email; }
    public function getValue(): string { return $this->email; }
}

// Update the email processor (line 549-551)
public function canProcess(object $value): bool
{
    return $value instanceof Email;
}

// Update process method (line 554-559)
public function process(object $value, callable $processor): mixed
{
    $email = $value->getValue();
    $parts = \explode('@', $email);
    return \substr($parts[0], 0, 2) . '***@' . $parts[1];
}

// Update context (lines 568-573)
$context = [
    'user_email' => new Email('[email protected]'),
    'admin_email' => new Email('[email protected]'),
    'regular_string' => 'not an email',
    'user_id' => 123,
];

Then assert the processed result actually contains masked emails.

---

583-635: Custom URL and credit card processors will never execute.

Both processors target strings (lines 589, 607), but the pipeline only routes objects to processors. These processors are never invoked, so URL parsing and CC masking don't occur. The test only checks that an RPC call happened.

Apply the same value-object wrapping approach as suggested for the email processor test: create URL and CreditCard classes implementing Stringable, update the processors to check instanceof, and update the context to use these wrapper objects.

---

656-699: Processor ordering test doesn't exercise ordering.

Both processors target integers (lines 662, 674), which are scalars. The object-processor pipeline never routes scalars to processors, so neither processor runs and ordering cannot be validated.

To test ordering, both processors must target the same object type. For example:

class Counter {
    public function __construct(public int $value) {}
}

$firstProcessor = new class implements ObjectProcessor {
    public function canProcess(object $value): bool
    {
        return $value instanceof Counter;
    }
    
    public function process(object $value, callable $processor): mixed
    {
        return 'first:' . $value->value;
    }
};

// Similar for secondProcessor...

$context = ['number' => new Counter(42)];

Then assert that the processed context reflects the first processor's transformation.

tests/Unit/Context/ObjectProcessor/StringableProcessorTest.php (1)

17-46: Clarify data provider and test naming.

The nonStringableProvider includes a Stringable case (returning true), and testCannotProcessNonStringable expects both true and false. This is confusing: the names imply "cannot process non-Stringable" but the implementation tests both positive and negative cases.

Consider renaming for clarity:

-    public static function nonStringableProvider(): array
+    public static function canProcessProvider(): array
     {
         return [
-            [new \stdClass(), false],
+            'non-stringable' => [new \stdClass(), false],
-            [new class implements \Stringable {
+            'stringable' => [new class implements \Stringable {
                 public function __toString(): string
                 {
                     return 'I am string';
                 }
             }, true],
         ];
     }

-    #[DataProvider('nonStringableProvider')]
-    public function testCannotProcessNonStringable(mixed $value, $expected): void
+    #[DataProvider('canProcessProvider')]
+    public function testCanProcess(mixed $value, bool $expected): void
     {
         $this->assertSame($expected, $this->processor->canProcess($value));
     }

src/Context/ObjectProcessor/FallbackProcessor.php (2)

23-25: Add callable/return annotations for Psalm.

Document the processor callable and the returned array shape to quiet MixedAssignment and improve IDE hints.

-    public function process(object $value, callable $processor): array
+    /**
+     * @param callable(mixed): mixed $processor
+     * @return array<string, mixed>
+     */
+    public function process(object $value, callable $processor): array

---

18-21: Suppress PHPMD unused parameter in canProcess.

Parameter is mandated by the interface. Suppress the warning instead of renaming.

-    public function canProcess(object $value): bool
+    /** @SuppressWarnings(PHPMD.UnusedFormalParameter) */
+    public function canProcess(object $value): bool

src/Context/ObjectProcessor/StringableProcessor.php (1)

23-26: LGTM; optionally silence unused $processor.

Implementation is correct. If tools complain, add a suppression or a no-op unset($processor);.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro